{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 标量、直方图、图像和张量可视化\n",
    "\n",
    "可以通过MindSpore提供的接口将训练过程中的标量、图像和张量记录到summary日志文件中，并通过MindInsight提供的可视化界面进行查看。\n",
    "\n",
    "接下来是本次流程的体验过程。\n",
    "\n",
    "## 整体流程\n",
    "\n",
    "1. 下载CIFAR-10二进制格式数据集。\n",
    "2. 对数据进行预处理。\n",
    "3. 定义AlexNet网络，在网络中使用summary算子记录数据。\n",
    "4. 训练网络，使用 `SummaryCollector` 记录损失值标量、权重梯度等参数。同时启动MindInsight服务，实时查看损失值、参数直方图、输入图像和张量的变化。\n",
    "5. 完成训练后，查看MindInsight看板中记录到的损失值标量、直方图、图像信息、张量信息。\n",
    "6. 分别单独记录损失值标量、直方图、图像信息和张量信息并查看可视化结果，查看损失值标量对比信息。\n",
    "7. 相关注意事项，关闭MindInsight服务。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 准备环节\n",
    "\n",
    "### 下载数据集\n",
    "\n",
    "本次流程使用CIFAR-10二进制格式数据集，下载地址为：<https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz>。\n",
    "\n",
    "CIFAR-10二进制格式数据集包含10个类别的60000个32x32彩色图像。每个类别6000个图像，包含50000张训练图像和10000张测试图像。数据集分为5个训练批次和1个测试批次，每个批次具有10000张图像。测试批次包含每个类别中1000个随机选择的图像，训练批次按随机顺序包含剩余图像（某个训练批次包含的一类图像可能比另一类更多）。其中，每个训练批次精确地包含对应每个类别的5000张图像。\n",
    "\n",
    "执行下面一段代码下载CIFAR-10二进制格式数据集到当前工作目录，如果已经下载过数据集，则不重复下载。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "*Checking DataSets Path.*\n",
      "Downloading CIFAR-10 DataSets.\n",
      "data_batch_1.bin is ok\n",
      "data_batch_2.bin is ok\n",
      "data_batch_3.bin is ok\n",
      "data_batch_4.bin is ok\n",
      "data_batch_5.bin is ok\n",
      "Downloaded CIFAR-10 DataSets Already.\n"
     ]
    }
   ],
   "source": [
    "import os, shutil\n",
    "import urllib.request\n",
    "from urllib.parse import urlparse\n",
    "\n",
    "\n",
    "def callbackfunc(blocknum, blocksize, totalsize):\n",
    "    percent = 100.0 * blocknum * blocksize / totalsize\n",
    "    if percent > 100:\n",
    "        percent = 100\n",
    "    print(\"downloaded {:.1f}\".format(percent), end=\"\\r\")\n",
    "\n",
    "def _download_dataset():\n",
    "    ds_url = \"https://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz\"\n",
    "    file_base_name = urlparse(ds_url).path.split(\"/\")[-1]\n",
    "    file_name = os.path.join(\"./DataSets\", file_base_name)\n",
    "    if not os.path.exists(file_name):\n",
    "        urllib.request.urlretrieve(ds_url, file_name, callbackfunc)\n",
    "    print(\"{:*^25}\".format(\"DataSets Downloaded\"))\n",
    "    shutil.unpack_archive(file_name, extract_dir=\"./DataSets/cifar-10-binary\")\n",
    "\n",
    "def _copy_dataset(ds_part, dest_path):\n",
    "    data_source_path = \"./DataSets/cifar-10-binary/cifar-10-batches-bin\"\n",
    "    ds_part_source_path = os.path.join(data_source_path, ds_part)\n",
    "    if not os.path.exists(ds_part_source_path):\n",
    "        _download_dataset()\n",
    "    shutil.copy(ds_part_source_path, dest_path)\n",
    "\n",
    "def download_cifar10_dataset():\n",
    "    ds_base_path = \"./DataSets/cifar-10-batches-bin\"\n",
    "    train_path = os.path.join(ds_base_path, \"train\")\n",
    "    test_path = os.path.join(ds_base_path, \"test\")\n",
    "    print(\"{:*^25}\".format(\"Checking DataSets Path.\"))\n",
    "    if not os.path.exists(train_path) and not os.path.exists(train_path):\n",
    "        os.makedirs(train_path)\n",
    "        os.makedirs(test_path)\n",
    "    print(\"{:*^25}\".format(\"Downloading CIFAR-10 DataSets.\"))\n",
    "    for i in range(1, 6):\n",
    "        train_part = \"data_batch_{}.bin\".format(i)\n",
    "        if not os.path.exists(os.path.join(train_path, train_part)):\n",
    "           _copy_dataset(train_part, train_path)\n",
    "        pops = train_part + \" is ok\"\n",
    "        print(\"{:*^20}\".format(pops))\n",
    "    test_part = \"test_batch.bin\"\n",
    "    if not os.path.exists(os.path.join(test_path, test_part)):\n",
    "        _copy_dataset(test_part, test_path)\n",
    "        print(\"{:*^20}\".format(test_part+\" is ok\"))\n",
    "    print(\"{:*^25}\".format(\"Downloaded CIFAR-10 DataSets Already.\"))\n",
    "\n",
    "download_cifar10_dataset()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下载数据集后，CIFAR-10数据集目录（`DataSets`）结构如下所示。\n",
    "\n",
    "```shell\n",
    "    $ tree DataSets\n",
    "    DataSets\n",
    "    └── cifar-10-batches-bin\n",
    "        ├── test\n",
    "        │   └── test_batch.bin\n",
    "        └── train\n",
    "            ├── data_batch_1.bin\n",
    "            ├── data_batch_2.bin\n",
    "            ├── data_batch_3.bin\n",
    "            ├── data_batch_4.bin\n",
    "            └── data_batch_5.bin\n",
    "\n",
    "```\n",
    "\n",
    "其中：\n",
    "- `test_batch.bin`文件为测试数据集文件。\n",
    "- `data_batch_1.bin`文件为第1批次训练数据集文件。\n",
    "- `data_batch_2.bin`文件为第2批次训练数据集文件。\n",
    "- `data_batch_3.bin`文件为第3批次训练数据集文件。\n",
    "- `data_batch_4.bin`文件为第4批次训练数据集文件。\n",
    "- `data_batch_5.bin`文件为第5批次训练数据集文件。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据处理\n",
    "\n",
    "好的数据集可以有效提高训练精度和效率，在加载数据集前，会进行一些处理，增加数据的可用性和随机性。下面一段代码定义函数`create_dataset_cifar10`来进行数据处理操作，并创建训练数据集(`ds_train`)和测试数据集(`ds_eval`)。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.dataset as ds\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "import mindspore.dataset.transforms.vision.c_transforms as CV\n",
    "from mindspore.common import dtype as mstype\n",
    "\n",
    "\n",
    "def create_dataset_cifar10(data_path, batch_size=32, repeat_size=1, status=\"train\"):\n",
    "    \"\"\"\n",
    "    create dataset for train or test\n",
    "    \"\"\"\n",
    "    cifar_ds = ds.Cifar10Dataset(data_path)\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "\n",
    "    resize_op = CV.Resize(size=(227, 227))\n",
    "    rescale_op = CV.Rescale(rescale, shift)\n",
    "    normalize_op = CV.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n",
    "    if status == \"train\":\n",
    "        random_crop_op = CV.RandomCrop([32, 32], [4, 4, 4, 4])\n",
    "        random_horizontal_op = CV.RandomHorizontalFlip()\n",
    "    channel_swap_op = CV.HWC2CHW()\n",
    "    typecast_op = C.TypeCast(mstype.int32)\n",
    "    cifar_ds = cifar_ds.map(input_columns=\"label\", operations=typecast_op)\n",
    "    if status == \"train\":\n",
    "        cifar_ds = cifar_ds.map(input_columns=\"image\", operations=random_crop_op)\n",
    "        cifar_ds = cifar_ds.map(input_columns=\"image\", operations=random_horizontal_op)\n",
    "    cifar_ds = cifar_ds.map(input_columns=\"image\", operations=resize_op)\n",
    "    cifar_ds = cifar_ds.map(input_columns=\"image\", operations=rescale_op)\n",
    "    cifar_ds = cifar_ds.map(input_columns=\"image\", operations=normalize_op)\n",
    "    cifar_ds = cifar_ds.map(input_columns=\"image\", operations=channel_swap_op)\n",
    "\n",
    "    cifar_ds = cifar_ds.shuffle(buffer_size=1000)\n",
    "    cifar_ds = cifar_ds.batch(batch_size, drop_remainder=True)\n",
    "    cifar_ds = cifar_ds.repeat(repeat_size)\n",
    "    return cifar_ds\n",
    "\n",
    "ds_train = create_dataset_cifar10(data_path=\"./DataSets/cifar-10-batches-bin/train\")\n",
    "ds_eval = create_dataset_cifar10(\"./DataSets/cifar-10-batches-bin/test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 抽取数据集图像\n",
    "\n",
    "执行以下一段代码，抽取上步创建好的训练数据集`ds_train`中第一个`batch`的32张图像以及对应的类别名称进行展示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 32 images with label of the first batch in ds_train are showed below:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 32 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "label_list = [\"airplane\", \"automobile\", \"bird\", \"cat\", \"deer\", \"dog\", \"rog\", \"horse\", \"ship\", \"truck\"]\n",
    "print(\"The 32 images with label of the first batch in ds_train are showed below:\")\n",
    "ds_iterator = ds_train.create_dict_iterator()\n",
    "ds_iterator.get_next()\n",
    "batch_1 = ds_iterator.get_next()\n",
    "batch_image = batch_1[\"image\"]\n",
    "batch_label = batch_1[\"label\"]\n",
    "%matplotlib inline\n",
    "plt.figure(dpi=144)\n",
    "for i,image in enumerate(batch_image):\n",
    "    plt.subplot(4, 8, i+1)\n",
    "    plt.subplots_adjust(wspace=0.2, hspace=0.2)\n",
    "    image = image/np.amax(image)\n",
    "    image = np.clip(image, 0, 1)\n",
    "    image = np.transpose(image,(1,2,0))\n",
    "    plt.imshow(image)\n",
    "    num = batch_label[i]\n",
    "    plt.title(f\"image {i+1}\\n{label_list[num]}\", y=-0.65, fontdict={\"fontsize\":8})\n",
    "    plt.axis('off')    \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用Summary算子记录数据\n",
    "\n",
    "在进行训练之前，需定义神经网络模型，本流程采用AlexNet网络，以下一段代码中定义AlexNet网络结构。\n",
    "\n",
    "MindSpore提供了两种方法进行记录数据，分别为：\n",
    "- 通过Summary算子记录数据\n",
    "- 通过 `SummaryCollector` 这个callback进行记录\n",
    "\n",
    "下面展示在AlexNet网络中使用Summary算子记录输入图像和张量数据。\n",
    "\n",
    "- 使用 `ImageSummary` 记录输入图像数据。\n",
    "\n",
    "    1. 在 `__init__` 方法中初始化 `ImageSummary`。\n",
    "        \n",
    "        ```python\n",
    "        # Init ImageSummary\n",
    "        self.image_summary = P.ImageSummary()\n",
    "        ```\n",
    "    \n",
    "    2. 在 `construct` 方法中使用 `ImageSummary` 算子记录输入图像。其中 \"Image\" 为该数据的名称，MindInsight在展示时，会将该名称展示出来以方便识别是哪个数据。\n",
    "    \n",
    "        ```python\n",
    "        # Record image by Summary operator\n",
    "        self.image_summary(\"Image\", x)\n",
    "        ```\n",
    "        \n",
    "- 使用 `TensorSummary` 记录张量数据。\n",
    "\n",
    "    1. 在 `__init__` 方法中初始化 `TensorSummary`。\n",
    "        \n",
    "        ```python\n",
    "        # Init TensorSummary\n",
    "        self.tensor_summary = P.TensorSummary()\n",
    "        ```\n",
    "        \n",
    "    2. 在`construct`方法中使用`TensorSummary`算子记录张量数据。其中\"Tensor\"为该数据的名称。\n",
    "    \n",
    "        ```python\n",
    "        # Record tensor by Summary operator\n",
    "        self.tensor_summary(\"Tensor\", x)\n",
    "        ```\n",
    "\n",
    "当前支持的Summary算子:\n",
    "\n",
    "- [ScalarSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html?highlight=scalarsummary#mindspore.ops.operations.ScalarSummary): 记录标量数据\n",
    "- [TensorSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html?highlight=tensorsummary#mindspore.ops.operations.TensorSummary): 记录张量数据\n",
    "- [ImageSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html?highlight=imagesummary#mindspore.ops.operations.ImageSummary): 记录图片数据\n",
    "- [HistogramSummary](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.ops.operations.html?highlight=histogramsummar#mindspore.ops.operations.HistogramSummary): 将张量数据转为直方图数据记录"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore.nn as nn\n",
    "from mindspore.common.initializer import TruncatedNormal\n",
    "from mindspore.ops import operations as P\n",
    "\n",
    "def conv(in_channels, out_channels, kernel_size, stride=1, padding=0, pad_mode=\"valid\"):\n",
    "    weight = weight_variable()\n",
    "    return nn.Conv2d(in_channels, out_channels,\n",
    "                     kernel_size=kernel_size, stride=stride, padding=padding,\n",
    "                     weight_init=weight, has_bias=False, pad_mode=pad_mode)\n",
    "\n",
    "def fc_with_initialize(input_channels, out_channels):\n",
    "    weight = weight_variable()\n",
    "    bias = weight_variable()\n",
    "    return nn.Dense(input_channels, out_channels, weight, bias)\n",
    "\n",
    "def weight_variable():\n",
    "    return TruncatedNormal(0.02)\n",
    "\n",
    "\n",
    "class AlexNet(nn.Cell):\n",
    "    \"\"\"\n",
    "    Alexnet\n",
    "    \"\"\"\n",
    "    def __init__(self, num_classes=10, channel=3):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.conv1 = conv(channel, 96, 11, stride=4)\n",
    "        self.conv2 = conv(96, 256, 5, pad_mode=\"same\")\n",
    "        self.conv3 = conv(256, 384, 3, pad_mode=\"same\")\n",
    "        self.conv4 = conv(384, 384, 3, pad_mode=\"same\")\n",
    "        self.conv5 = conv(384, 256, 3, pad_mode=\"same\")\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = P.MaxPool(ksize=3, strides=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = fc_with_initialize(6*6*256, 4096)\n",
    "        self.fc2 = fc_with_initialize(4096, 4096)\n",
    "        self.fc3 = fc_with_initialize(4096, num_classes)\n",
    "        # Init TensorSummary\n",
    "        self.tensor_summary = P.TensorSummary()\n",
    "        # Init ImageSummary\n",
    "        self.image_summary = P.ImageSummary()\n",
    "\n",
    "    def construct(self, x):\n",
    "        # Record image by Summary operator\n",
    "        self.image_summary(\"Image\", x)\n",
    "        x = self.conv1(x)\n",
    "        # Record tensor by Summary operator\n",
    "        self.tensor_summary(\"Tensor\", x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用 `SummaryCollector` 记录数据\n",
    "\n",
    "下面展示使用`SummaryCollector`来记录标量、直方图信息。\n",
    "\n",
    "在MindSpore中通过`Callback`机制，提供支持快速简易地收集损失值、参数权重、梯度等信息的`Callback`, 叫做`SummaryCollector`（详细的用法可以参考API文档中[mindspore.train.callback.SummaryCollector](https://www.mindspore.cn/api/zh-CN/master/api/python/mindspore/mindspore.train.html?highlight=summarycollector#mindspore.train.callback.SummaryCollector)）。`SummaryCollector`使用方法如下： \n",
    "\n",
    "`SummaryCollector` 提供 `collect_specified_data` 参数，允许自定义想要收集的数据。\n",
    "\n",
    "下面的代码展示通过 `SummaryCollector` 收集损失值以及卷积层的参数值，参数值在MindInsight中以直方图展示。\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "```python\n",
    "specified={\"collect_metric\": True, \"histogram_regular\": \"^conv1.*|^conv2.*\"}\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_01\", \n",
    "                                        collect_specified_data=specified, \n",
    "                                        collect_freq=1, \n",
    "                                        keep_default_action=False, \n",
    "                                        collect_tensor_freq=200)\n",
    "```\n",
    "\n",
    "- `summary_dir`：指定日志保存的路径。\n",
    "- `collect_specified_data`：指定需要记录的信息。\n",
    "- `collect_freq`：指定使用`SummaryCollector`记录数据的频率。\n",
    "- `keep_default_action`：指定是否除记录除指定信息外的其他数据信息。\n",
    "- `collect_tensor_freq`：指定记录张量信息的频率。\n",
    "- `\"collect_metric\"`为记录损失值标量信息。\n",
    "- `\"histogram_regular\"`为记录`conv1`层和`conv2`层直方图信息。\n",
    "\n",
    "&emsp;&emsp;程序运行过程中将在本地`8080`端口自动启动MindInsight服务并自动遍历读取当前notebook目录下`summary_dir`子目录下所有日志文件、解析进行可视化展示。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 导入模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import mindspore.nn as nn\n",
    "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, LossMonitor, TimeMonitor\n",
    "from mindspore.train import Model\n",
    "from mindspore.nn.metrics import Accuracy\n",
    "from mindspore.train.callback import SummaryCollector\n",
    "from mindspore.train.serialization import load_checkpoint, load_param_into_net\n",
    "from mindspore import Tensor\n",
    "from mindspore import context\n",
    "\n",
    "device_target = \"GPU\"\n",
    "context.set_context(mode=context.GRAPH_MODE, device_target=device_target)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 定义学习率\n",
    "\n",
    "以下一段代码定义学习率。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def get_lr(current_step, lr_max, total_epochs, steps_per_epoch):\n",
    "    \"\"\"\n",
    "    generate learning rate array\n",
    "\n",
    "    Args:\n",
    "       current_step(int): current steps of the training\n",
    "       lr_max(float): max learning rate\n",
    "       total_epochs(int): total epoch of training\n",
    "       steps_per_epoch(int): steps of one epoch\n",
    "\n",
    "    Returns:\n",
    "       np.array, learning rate array\n",
    "    \"\"\"\n",
    "    lr_each_step = []\n",
    "    total_steps = steps_per_epoch * total_epochs\n",
    "    decay_epoch_index = [0.8 * total_steps]\n",
    "    for i in range(total_steps):\n",
    "        if i < decay_epoch_index[0]:\n",
    "            lr = lr_max\n",
    "        else:\n",
    "            lr = lr_max * 0.1\n",
    "        lr_each_step.append(lr)\n",
    "    lr_each_step = np.array(lr_each_step).astype(np.float32)\n",
    "    learning_rate = lr_each_step[current_step:]\n",
    "\n",
    "    return learning_rate\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 执行训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1, loss is 2.3056953\n",
      "epoch: 1 step: 2, loss is 2.3169184\n",
      "epoch: 1 step: 3, loss is 2.2732773\n",
      "epoch: 1 step: 4, loss is 2.3223817\n",
      "epoch: 1 step: 5, loss is 2.300379\n",
      "epoch: 1 step: 6, loss is 2.2816362\n",
      "epoch: 1 step: 7, loss is 2.3317387\n",
      "epoch: 1 step: 8, loss is 2.2595024\n",
      "epoch: 1 step: 9, loss is 2.3138928\n",
      "epoch: 1 step: 10, loss is 2.294712\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 10 step: 1553, loss is 0.23232733\n",
      "epoch: 10 step: 1554, loss is 0.35622978\n",
      "epoch: 10 step: 1555, loss is 0.24221122\n",
      "epoch: 10 step: 1556, loss is 0.2082262\n",
      "epoch: 10 step: 1557, loss is 0.29972154\n",
      "epoch: 10 step: 1558, loss is 0.32628897\n",
      "epoch: 10 step: 1559, loss is 0.44762093\n",
      "epoch: 10 step: 1560, loss is 0.4621265\n",
      "epoch: 10 step: 1561, loss is 0.13807176\n",
      "epoch: 10 step: 1562, loss is 0.40322578\n",
      "Epoch time: 242827.643, per step time: 155.459\n",
      "============== Starting Testing ==============\n",
      "============== {'Accuracy': 0.8299278846153846} ==============\n"
     ]
    }
   ],
   "source": [
    "\n",
    "network = AlexNet(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "lr = Tensor(get_lr(0, 0.002, 10, ds_train.get_dataset_size()))\n",
    "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_alexnet\", config=config_ck)\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
    "\n",
    "summary_base_dir = \"./summary_dir\"\n",
    "os.system(f\"mindinsight start --summary-base-dir  {summary_base_dir} --port=8080\")\n",
    "\n",
    "# Init a SummaryCollector callback instance, and use it in model.train or model.eval\n",
    "specified = {\"collect_metric\": True, \"histogram_regular\": \"^conv1.*|^conv2.*\"}\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_01\", collect_specified_data=specified, collect_freq=1, keep_default_action=False, collect_tensor_freq=200)\n",
    "\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(epoch=10, train_dataset=ds_train, callbacks=[time_cb, ckpoint_cb, LossMonitor(), summary_collector], dataset_sink_mode=True)\n",
    "\n",
    "print(\"============== Starting Testing ==============\")\n",
    "param_dict = load_checkpoint(\"checkpoint_alexnet-10_1562.ckpt\")\n",
    "load_param_into_net(network, param_dict)\n",
    "acc = model.eval(ds_eval, callbacks=summary_collector, dataset_sink_mode=True)\n",
    "print(\"============== {} ==============\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MindInsight看板\n",
    "\n",
    "在本地浏览器中打开地址：`127.0.0.1:8080`，进入到可视化面板。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/mindinsight_panel.png)\n",
    "\n",
    "在上图所示面板中可以看到`summary_01`日志文件目录，点击**训练看板**进入到下图所示的训练数据展示面板，该面板展示了标量数据、直方图、图像和张量信息，并随着训练、测试的进行实时刷新数据，实时显示训练过程参数的变化情况。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/mindinsight_panel2.png)\n",
    "\n",
    "### 标量可视化\n",
    "\n",
    "标量可视化用于展示训练过程中标量的变化趋势，点击打开标量信息展示面板，该面板记录了迭代计算过程中的损失值标量信息，如下图展示了损失值标量趋势图。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/scalar_panel.png)\n",
    "\n",
    "上图展示了神经网络在训练过程中损失值的变化过程。横坐标是训练步骤，纵坐标是损失值。\n",
    "\n",
    "图中右上角有几个按钮功能，从左到右功能分别是全屏展示，切换Y轴比例，开启/关闭框选，分步回退和还原图形。\n",
    "\n",
    "- 全屏展示即全屏展示该标量曲线，再点击一次即可恢复。\n",
    "- 切换Y轴比例是指可以将Y轴坐标进行对数转换。\n",
    "- 开启/关闭框选是指可以框选图中部分区域，并放大查看该区域，可以在已放大的图形上叠加框选。\n",
    "- 分步回退是指对同一个区域连续框选并放大查看时，可以逐步撤销操作。\n",
    "- 还原图形是指进行了多次框选后，点击此按钮可以将图还原回原始状态。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/scalar_select.png)\n",
    "\n",
    "上图展示的标量可视化的功能区，提供了根据选择不同标签，水平轴的不同维度和平滑度来查看标量信息的功能。\n",
    "\n",
    "- 标签选择：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的标量信息。\n",
    "- 水平轴：可以选择“步骤”、“相对时间”、“绝对时间”中的任意一项，来作为标量曲线的水平轴。\n",
    "- 平滑度：可以通过调整平滑度，对标量曲线进行平滑处理。\n",
    "- 标量合成：可以选中两条标量曲线进行合成并展示在一个图中，以方便对两条曲线进行对比或者查看合成后的图。\n",
    "  标量合成的功能区与标量可视化的功能区相似。其中与标量可视化功能区不一样的地方，在于标签选择时，标量合成功能最多只能同时选择两个标签，将其曲线合成并展示。\n",
    "\n",
    "### 直方图可视化\n",
    "\n",
    "\n",
    "直方图用于将用户所指定的张量以直方图的形式展示。点击打开直方图展示面板，以直方图的形式记录了在迭代过程中所有层参数分布信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram_panel.png)\n",
    "\n",
    "如下图为`conv1`层参数分布信息，点击图中右上角，可以将图放大。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram.png)\n",
    "\n",
    "下图为直方图功能区。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram_func.png)\n",
    "\n",
    "上图展示直方图的功能区，包含以下内容：\n",
    "\n",
    "- 标签选择：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的直方图。\n",
    "- 纵轴：可以选择步骤、相对时间、绝对时间中的任意一项，来作为直方图纵轴显示的数据。\n",
    "- 视角：可以选择正视和俯视中的一种。正视是指从正面的角度查看直方图，此时不同步骤之间的数据会覆盖在一起。俯视是指偏移以45度角俯视直方图区域，这时可以呈现不同步骤之间数据的差异。\n",
    "\n",
    "### 图像可视化\n",
    "\n",
    "图像可视化用于展示用户所指定的图片。点击图像展示面板，展示了每个一步进行处理的图像信息。\n",
    "\n",
    "下图为展示`summary_01`记录的图像信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/image_panel.png)\n",
    "\n",
    "通过滑动上图中的\"步骤\"滑条，查看不同步骤的图片。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/image_function.png)\n",
    "\n",
    "上图展示图像可视化的功能区，提供了选择查看不同标签，不同亮度和不同对比度来查看图片信息。\n",
    "\n",
    "- 标签：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的图片信息。\n",
    "- 亮度调整：可以调整所展示的所有图片亮度。\n",
    "- 对比度调整：可以调整所展示的所有图片对比度。\n",
    "\n",
    "### 张量可视化\n",
    "\n",
    "张量可视化用于将张量以表格以及直方图的形式进行展示。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/tensor_func.png)\n",
    "\n",
    "上图展示了张量可视化的功能区，包含以下内容：\n",
    "\n",
    "- 标签选择：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的表格数据或者直方图。\n",
    "- 视图：可以选择表格或者直方图来展示tensor数据。在直方图视图下存在纵轴和视角的功能选择。\n",
    "- 纵轴：可以选择步骤、相对时间、绝对时间中的任意一项，来作为直方图纵轴显示的数据。\n",
    "- 视角：可以选择正视和俯视中的一种。正视是指从正面的角度查看直方图，此时不同步骤之间的数据会覆盖在一起。俯视是指 偏移以45度角俯视直方图区域，这时可以呈现不同步骤之间数据的差异。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/tensor.png)\n",
    "\n",
    "上图中将用户所记录的张量以表格的形式展示，包含以下功能：\n",
    "\n",
    "- 点击表格右边小方框按钮，可以将表格放大。\n",
    "- 表格中白色方框显示当前展示的是哪个维度下的张量数据，其中冒号\":\"表示当前维度的所有值，可以在方框输入对应的索引或者:后按Enter键或者点击后边的打勾按钮来查询特定维度的张量数据。 假设某维度是32，则其索引范围是-32到31。注意：可以查询0维到2维的张量数据，不支持查询超过两维的张量数据，即不能设置超过两个冒号\":\"的查询条件。\n",
    "- 拖拽表格下方的空心圆圈可以查询特定步骤的张量数据。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 单独记录数据\n",
    "\n",
    "以上流程为整体展示Summary算子能记录到的所有类型数据，也可以单独记录关心的数据，以降低性能开销和日志文件大小。\n",
    "\n",
    "### 单独记录损失值标量\n",
    "\n",
    "1. 配置`specified`参数为：\n",
    "\n",
    "```python\n",
    "specified={\"collect_metric\": True}\n",
    "```\n",
    "\n",
    "2. 配置`summary_collector`为：\n",
    "\n",
    "```python\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_loss_only\", \n",
    "                                     collect_specified_data=specified, \n",
    "                                     collect_freq=1, \n",
    "                                     keep_default_action=False)\n",
    "```\n",
    "\n",
    "&emsp;&emsp;运行以下一段代码，单独记录损失值标量信息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1, loss is 2.316685\n",
      "epoch: 1 step: 2, loss is 2.3051994\n",
      "epoch: 1 step: 3, loss is 2.2948198\n",
      "epoch: 1 step: 4, loss is 2.3207984\n",
      "epoch: 1 step: 5, loss is 2.3364246\n",
      "epoch: 1 step: 6, loss is 2.2956452\n",
      "epoch: 1 step: 7, loss is 2.2634928\n",
      "epoch: 1 step: 8, loss is 2.3085115\n",
      "epoch: 1 step: 9, loss is 2.254295\n",
      "epoch: 1 step: 10, loss is 2.3339896\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 10 step: 1556, loss is 0.40271574\n",
      "epoch: 10 step: 1557, loss is 0.5172653\n",
      "epoch: 10 step: 1558, loss is 0.3401278\n",
      "epoch: 10 step: 1559, loss is 0.4081525\n",
      "epoch: 10 step: 1560, loss is 0.31565452\n",
      "epoch: 10 step: 1561, loss is 0.41298962\n",
      "epoch: 10 step: 1562, loss is 0.24210417\n",
      "Epoch time: 54385.175, per step time: 34.818\n",
      "============== Starting Testing ==============\n",
      "============== {'Accuracy': 0.8254206730769231} ==============\n"
     ]
    }
   ],
   "source": [
    "class AlexNet(nn.Cell):\n",
    "    \"\"\"\n",
    "    Alexnet\n",
    "    \"\"\"\n",
    "    def __init__(self, num_classes=10, channel=3):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.conv1 = conv(channel, 96, 11, stride=4)\n",
    "        self.conv2 = conv(96, 256, 5, pad_mode=\"same\")\n",
    "        self.conv3 = conv(256, 384, 3, pad_mode=\"same\")\n",
    "        self.conv4 = conv(384, 384, 3, pad_mode=\"same\")\n",
    "        self.conv5 = conv(384, 256, 3, pad_mode=\"same\")\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = P.MaxPool(ksize=3, strides=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = fc_with_initialize(6*6*256, 4096)\n",
    "        self.fc2 = fc_with_initialize(4096, 4096)\n",
    "        self.fc3 = fc_with_initialize(4096, num_classes)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "lr = Tensor(get_lr(0, 0.002, 10, ds_train.get_dataset_size()))\n",
    "network = AlexNet(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_alexnet\", config=config_ck)\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
    "\n",
    "# Init a SummaryCollector callback instance, and use it in model.train or model.eval\n",
    "specified = {\"collect_metric\": True}\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_loss_only\", collect_specified_data=specified, collect_freq=1, keep_default_action=False)\n",
    "\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(epoch=10, train_dataset=ds_train, callbacks=[time_cb, ckpoint_cb, LossMonitor(), summary_collector], dataset_sink_mode=True)\n",
    "\n",
    "print(\"============== Starting Testing ==============\")\n",
    "param_dict = load_checkpoint(\"checkpoint_alexnet_1-10_1562.ckpt\")\n",
    "load_param_into_net(network, param_dict)\n",
    "acc = model.eval(ds_eval, callbacks=summary_collector, dataset_sink_mode=True)\n",
    "print(\"============== {} ==============\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时点击打开MindInsight**训练列表**看板中的`./summary_loss_only`目录，如下图所示，可以看到只记录有损失值标量信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/loss_scalar_only.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单独记录参数分布直方图\n",
    "\n",
    "1. 配置`specified`参数为只记录`conv1`层直方图信息：\n",
    "\n",
    "```python\n",
    "specified = {\"histogram_regular\": \"^conv1.*\"}\n",
    "```\n",
    "2. 配置`summary_collector`为：\n",
    "\n",
    "```python\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_histogram_only\", \n",
    "                                     collect_specified_data=specified, \n",
    "                                     collect_freq=1,\n",
    "                                     keep_default_action=False)\n",
    "```\n",
    "\n",
    "&emsp;&emsp;运行以下一段代码记录`conv1`层参数直方图信息（为了减少内存占用和减少训练时间，在后续的训练中设置`epoch`为1）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1, loss is 2.2941067\n",
      "epoch: 1 step: 2, loss is 2.2770133\n",
      "epoch: 1 step: 3, loss is 2.2869372\n",
      "epoch: 1 step: 4, loss is 2.261474\n",
      "epoch: 1 step: 5, loss is 2.3582025\n",
      "epoch: 1 step: 6, loss is 2.290377\n",
      "epoch: 1 step: 7, loss is 2.2761602\n",
      "epoch: 1 step: 8, loss is 2.3452077\n",
      "epoch: 1 step: 9, loss is 2.2613692\n",
      "epoch: 1 step: 10, loss is 2.3617961\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 1 step: 1552, loss is 0.9691028\n",
      "epoch: 1 step: 1553, loss is 1.1841048\n",
      "epoch: 1 step: 1554, loss is 1.3479778\n",
      "epoch: 1 step: 1555, loss is 1.2386065\n",
      "epoch: 1 step: 1556, loss is 1.0223479\n",
      "epoch: 1 step: 1557, loss is 1.1582826\n",
      "epoch: 1 step: 1558, loss is 0.87887794\n",
      "epoch: 1 step: 1559, loss is 0.956085\n",
      "epoch: 1 step: 1560, loss is 1.3973256\n",
      "epoch: 1 step: 1561, loss is 1.234511\n",
      "epoch: 1 step: 1562, loss is 1.0787828\n",
      "Epoch time: 62971.025, per step time: 40.314\n",
      "============== Starting Testing ==============\n",
      "============== {'Accuracy': 0.5687099358974359} ==============\n"
     ]
    }
   ],
   "source": [
    "lr = Tensor(get_lr(0, 0.002, 1, ds_train.get_dataset_size()))\n",
    "network = AlexNet(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_alexnet\", config=config_ck)\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
    "\n",
    "# Init a SummaryCollector callback instance, and use it in model.train or model.eval\n",
    "specified = {\"histogram_regular\": \"^conv1.*\"}\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_histogram_only\", collect_specified_data=specified, collect_freq=1, keep_default_action=False)\n",
    "\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(epoch=1, train_dataset=ds_train, callbacks=[time_cb, ckpoint_cb, LossMonitor(), summary_collector], dataset_sink_mode=True)\n",
    "\n",
    "print(\"============== Starting Testing ==============\")\n",
    "param_dict = load_checkpoint(\"checkpoint_alexnet_2-1_1562.ckpt\")\n",
    "load_param_into_net(network, param_dict)\n",
    "acc = model.eval(ds_eval, callbacks=summary_collector, dataset_sink_mode=True)\n",
    "print(\"============== {} ==============\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时点击打开MindInsight**训练列表**看板中的`./summary_histogram_only`目录。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram_only.png)\n",
    "\n",
    "在MindInsight面板中，如上图所示，只展示了直方图信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/histogram_only_all.png)\n",
    "\n",
    "点击进入直方图面板，如上图所示，只展示了`conv1`层的直方图信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单独记录张量数据\n",
    "\n",
    "1. 在AlexNet网络的`__init__`方法中初始化`TensorSummary`。\n",
    "2. 在AlexNet网络的`construct`方法中使用`TensorSummary`算子记录张量数据。\n",
    "3. 配置`summary_collector`为：\n",
    "\n",
    "```python\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_tensor_only\", \n",
    "                                     collect_specified_data=None, \n",
    "                                     collect_freq=1,\n",
    "                                     keep_default_action=False, \n",
    "                                     collect_tensor_freq=50)\n",
    "```\n",
    "\n",
    "&emsp;&emsp;运行以下一段代码只记录张量数据。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1, loss is 2.3178232\n",
      "epoch: 1 step: 2, loss is 2.3172731\n",
      "epoch: 1 step: 3, loss is 2.3256557\n",
      "epoch: 1 step: 4, loss is 2.3034613\n",
      "epoch: 1 step: 5, loss is 2.318819\n",
      "epoch: 1 step: 6, loss is 2.2775433\n",
      "epoch: 1 step: 7, loss is 2.322216\n",
      "epoch: 1 step: 8, loss is 2.2980762\n",
      "epoch: 1 step: 9, loss is 2.3208668\n",
      "epoch: 1 step: 10, loss is 2.3162236\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 1 step: 1552, loss is 1.5239879\n",
      "epoch: 1 step: 1553, loss is 1.3195564\n",
      "epoch: 1 step: 1554, loss is 1.2827079\n",
      "epoch: 1 step: 1555, loss is 1.0843871\n",
      "epoch: 1 step: 1556, loss is 1.2715582\n",
      "epoch: 1 step: 1557, loss is 1.4982214\n",
      "epoch: 1 step: 1558, loss is 1.0394028\n",
      "epoch: 1 step: 1559, loss is 1.0470619\n",
      "epoch: 1 step: 1560, loss is 1.1495018\n",
      "epoch: 1 step: 1561, loss is 1.0332686\n",
      "epoch: 1 step: 1562, loss is 1.1649165\n",
      "Epoch time: 113988.939, per step time: 72.976\n",
      "============== Starting Testing ==============\n",
      "============== {'Accuracy': 0.5647035256410257} ==============\n"
     ]
    }
   ],
   "source": [
    "class AlexNet(nn.Cell):\n",
    "    \"\"\"\n",
    "    Alexnet\n",
    "    \"\"\"\n",
    "    def __init__(self, num_classes=10, channel=3):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.conv1 = conv(channel, 96, 11, stride=4)\n",
    "        self.conv2 = conv(96, 256, 5, pad_mode=\"same\")\n",
    "        self.conv3 = conv(256, 384, 3, pad_mode=\"same\")\n",
    "        self.conv4 = conv(384, 384, 3, pad_mode=\"same\")\n",
    "        self.conv5 = conv(384, 256, 3, pad_mode=\"same\")\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = P.MaxPool(ksize=3, strides=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = fc_with_initialize(6*6*256, 4096)\n",
    "        self.fc2 = fc_with_initialize(4096, 4096)\n",
    "        self.fc3 = fc_with_initialize(4096, num_classes)\n",
    "        # Init TensorSummary\n",
    "        self.tensor_summary = P.TensorSummary()\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        # Record tensor by Summary operator\n",
    "        self.tensor_summary(\"Tensor\", x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "lr = Tensor(get_lr(0, 0.002, 1, ds_train.get_dataset_size()))\n",
    "network = AlexNet(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_alexnet\", config=config_ck)\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
    "\n",
    "# Init a SummaryCollector callback instance, and use it in model.train or model.eval\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_tensor_only\", collect_specified_data=None, collect_freq=1, keep_default_action=False, collect_tensor_freq=50)\n",
    "\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(epoch=1, train_dataset=ds_train, callbacks=[time_cb, ckpoint_cb, LossMonitor(), summary_collector], dataset_sink_mode=True)\n",
    "\n",
    "print(\"============== Starting Testing ==============\")\n",
    "param_dict = load_checkpoint(\"checkpoint_alexnet_3-1_1562.ckpt\")\n",
    "load_param_into_net(network, param_dict)\n",
    "acc = model.eval(ds_eval, callbacks=summary_collector, dataset_sink_mode=True)\n",
    "print(\"============== {} ==============\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时点击打开MindInsight**训练列表**看板中的`./summary_tensor_only`目录，如下图所示，可以看到只记录有张量信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/tensor_only.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 单独记录图像\n",
    "\n",
    "1. 在AlexNet网络的`__init__`方法中初始化`ImageSummary`。\n",
    "2. 在AlexNet网络的`construct`方法中使用`ImageSummary`算子记录输入的图像。\n",
    "3. 配置`summary_collector`为：\n",
    "\n",
    "    ```python\n",
    "    summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_image_only\", \n",
    "                                         collect_specified_data=None, \n",
    "                                         collect_freq=1, \n",
    "                                         keep_default_action=False)\n",
    "    ```\n",
    "\n",
    "&emsp;&emsp;运行以下一段代码只记录张量数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============== Starting Training ==============\n",
      "epoch: 1 step: 1, loss is 2.3218322\n",
      "epoch: 1 step: 2, loss is 2.3194063\n",
      "epoch: 1 step: 3, loss is 2.3358874\n",
      "epoch: 1 step: 4, loss is 2.3217764\n",
      "epoch: 1 step: 5, loss is 2.3040292\n",
      "epoch: 1 step: 6, loss is 2.2832437\n",
      "epoch: 1 step: 7, loss is 2.31645\n",
      "epoch: 1 step: 8, loss is 2.3330472\n",
      "epoch: 1 step: 9, loss is 2.3014827\n",
      "epoch: 1 step: 10, loss is 2.310499\n",
      "\n",
      "...\n",
      "\n",
      "epoch: 1 step: 1552, loss is 1.293778\n",
      "epoch: 1 step: 1553, loss is 1.385756\n",
      "epoch: 1 step: 1554, loss is 1.2190051\n",
      "epoch: 1 step: 1555, loss is 1.2079114\n",
      "epoch: 1 step: 1556, loss is 1.0067248\n",
      "epoch: 1 step: 1557, loss is 1.2732614\n",
      "epoch: 1 step: 1558, loss is 1.0397598\n",
      "epoch: 1 step: 1559, loss is 1.1968248\n",
      "epoch: 1 step: 1560, loss is 1.2161392\n",
      "epoch: 1 step: 1561, loss is 1.135769\n",
      "epoch: 1 step: 1562, loss is 1.4535972\n",
      "Epoch time: 152835.351, per step time: 97.846\n",
      "============== Starting Testing ==============\n",
      "============== {'Accuracy': 0.5597956730769231} ==============\n"
     ]
    }
   ],
   "source": [
    "class AlexNet(nn.Cell):\n",
    "    \"\"\"\n",
    "    Alexnet\n",
    "    \"\"\"\n",
    "    def __init__(self, num_classes=10, channel=3):\n",
    "        super(AlexNet, self).__init__()\n",
    "        self.conv1 = conv(channel, 96, 11, stride=4)\n",
    "        self.conv2 = conv(96, 256, 5, pad_mode=\"same\")\n",
    "        self.conv3 = conv(256, 384, 3, pad_mode=\"same\")\n",
    "        self.conv4 = conv(384, 384, 3, pad_mode=\"same\")\n",
    "        self.conv5 = conv(384, 256, 3, pad_mode=\"same\")\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = P.MaxPool(ksize=3, strides=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc1 = fc_with_initialize(6*6*256, 4096)\n",
    "        self.fc2 = fc_with_initialize(4096, 4096)\n",
    "        self.fc3 = fc_with_initialize(4096, num_classes)\n",
    "        # Init ImageSummary\n",
    "        self.image_summary = P.ImageSummary()\n",
    "\n",
    "    def construct(self, x):\n",
    "        # Record image by Summary operator\n",
    "        self.image_summary(\"Image\", x)\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv3(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv4(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.conv5(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "lr = Tensor(get_lr(0, 0.002, 1, ds_train.get_dataset_size()))\n",
    "network = AlexNet(num_classes=10)\n",
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction=\"mean\")\n",
    "net_opt = nn.Momentum(network.trainable_params(), learning_rate=lr, momentum=0.9)\n",
    "time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())\n",
    "config_ck = CheckpointConfig(save_checkpoint_steps=1562, keep_checkpoint_max=10)\n",
    "ckpoint_cb = ModelCheckpoint(prefix=\"checkpoint_alexnet\", config=config_ck)\n",
    "model = Model(network, net_loss, net_opt, metrics={\"Accuracy\": Accuracy()})\n",
    "\n",
    "# Init a SummaryCollector callback instance, and use it in model.train or model.eval\n",
    "summary_collector = SummaryCollector(summary_dir=\"./summary_dir/summary_image_only\", collect_specified_data=None, collect_freq=1, keep_default_action=False)\n",
    "\n",
    "print(\"============== Starting Training ==============\")\n",
    "model.train(epoch=1, train_dataset=ds_train, callbacks=[time_cb, ckpoint_cb, LossMonitor(), summary_collector], dataset_sink_mode=True)\n",
    "\n",
    "print(\"============== Starting Testing ==============\")\n",
    "param_dict = load_checkpoint(\"checkpoint_alexnet_4-1_1562.ckpt\")\n",
    "load_param_into_net(network, param_dict)\n",
    "acc = model.eval(ds_eval, callbacks=summary_collector, dataset_sink_mode=True)\n",
    "print(\"============== {} ==============\".format(acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/image_only.png)\n",
    "\n",
    "在MindInsight面板中，如上图所示，只展示了输入图像信息。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 对比看板\n",
    "\n",
    "对比看板用于多次训练之间的数据对比。\n",
    "\n",
    "点击MindInsight看板中的**对比看板**，打开对比看板，可以得到多次（不同）训练搜集到的标量数据对比信息。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/multi_scalars.png)\n",
    "\n",
    "上图展示了`summary_01`（上图中红色曲线）和`summary_loss_only`（上图中蓝色曲线）的标量曲线对比效果，横坐标是训练步骤，纵坐标是标量值。\n",
    "\n",
    "![](https://gitee.com/mindspore/docs/raw/master/tutorials/notebook/mindinsight/images/multi_scalars_select.png)\n",
    "\n",
    "上图展示的对比看板可视的功能区，提供了根据选择不同训练或标签，水平轴的不同维度和平滑度来进行标量对比的功能。\n",
    "\n",
    "- 训练：提供了对所有训练进行多项选择的功能，用户可以通过勾选或关键字筛选所需的训练。\n",
    "- 标签：提供了对所有标签进行多项选择的功能，用户可以通过勾选所需的标签，查看对应的标量信息。\n",
    "- 水平轴：可以选择“步骤”、“相对时间”、“绝对时间”中的任意一项，来作为标量曲线的水平轴。\n",
    "- 平滑度：可以通过调整平滑度，对标量曲线进行平滑处理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 关闭MindInsight服务\n",
    "\n",
    "在终端命令行中执行以下代码关闭MindInsight服务。\n",
    "\n",
    "```shell\n",
    "mindinsight stop --port 8080\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 注意事项和规格\n",
    "- 在训练中使用Summary算子收集数据时，`HistogramSummary`算子会影响性能，所以请尽量少地使用。\n",
    "- 不能同时使用多个 `SummaryRecord` 实例 （`SummaryCollector` 中使用了 `SummaryRecord`）。\n",
    "- 为了控制列出summary文件目录的用时，MindInsight最多支持发现999个summary文件目录。\n",
    "- 出于性能上的考虑，MindInsight对比看板使用缓存机制加载训练的标量曲线数据，并进行以下限制：\n",
    "    - 对比看板只支持在缓存中的训练进行比较标量曲线对比。\n",
    "    - 缓存最多保留最新（按修改时间排列）的15个训练。\n",
    "    - 用户最多同时对比5个训练的标量曲线。\n",
    "- 为了控制内存占用，MindInsight对标签（tag）数目和步骤（step）数目进行了限制：\n",
    "    - 每个训练看板的最大标签数量为300个标签。标量标签、图片标签、计算图标签、参数分布图（直方图）标签、张量标签的数量总和不得超过300个。特别地，每个训练看板最多有10个计算图标签、6个张量标签。当实际标签数量超过这一限制时，将依照MindInsight的处理顺序，保留最近处理的300个标签。\n",
    "    - 每个训练看板的每个标量标签最多有1000个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "    - 每个训练看板的每个图片标签最多有10个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "    - 每个训练看板的每个参数分布图（直方图）标签最多有50个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "    - 每个训练看板的每个张量标签最多有20个步骤的数据。当实际步骤的数目超过这一限制时，将对数据进行随机采样，以满足这一限制。\n",
    "- 由于`TensorSummary`会记录完整Tensor数据，数据量通常会比较大，为了控制内存占用和出于性能上的考虑，MindInsight对Tensor的大小以及返回前端展示的数值个数进行以下限制：\n",
    "    - MindInsight最大支持加载含有1千万个数值的Tensor。\n",
    "    - Tensor加载后，在张量可视的表格视图下，最大支持查看10万个数值，如果所选择的维度查询得到的数值超过这一限制，则无法显示。\n",
    "- 由于张量可视（`TensorSummary`）会记录原始张量数据，需要的存储空间较大。使用`TensorSummary`前和训练过程中请注意检查系统存储空间充足。 通过以下方法可以降低张量可视功能的存储空间占用：\\\n",
    "&emsp;&emsp;1）避免使用`TensorSummary`记录较大的Tensor。\\\n",
    "&emsp;&emsp;2）减少网络中`TensorSummary`算子的使用个数。\n",
    "- 功能使用完毕后，请及时清理不再需要的训练日志，以释放磁盘空间。\n",
    "- 备注：估算`TensorSummary`空间使用量的方法如下：\n",
    "    - 一个`TensorSummary`数据的大小 ＝ Tensor中的数值个数 * 4 bytes。假设使用`TensorSummary`记录的Tensor大小为32 * 1 * 256 * 256，则一个`TensorSummary`数据大约需要32 * 1 * 256 * 256 * 4 bytes = 8,388,608 bytes = 8MiB。`TensorSummary`默认会记录20个步骤的数据，则记录这20组数据需要的空间约为20 * 8 MiB ＝ 160MiB。需要注意的是，由于数据结构等因素的开销，实际使用的存储空间会略大于160MiB。\n",
    "    - 当使用`TensorSummary`时，由于记录完整Tensor数据，训练日志文件较大，MindInsight需要更多时间解析训练日志文件，请耐心等待。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "本次体验流程为完整的MindSpore深度学习及MindInsight可视化展示的过程，包括了下载数据集及预处理过程，构建网络、损失函数和优化器过程，生成模型并进行训练、验证的过程，以及启动MindInsight服务进行训练过程可视化展示。读者可以基于本次体验流程构建自己的网络模型进行训练，并使用`SummaryCollector`以及Summary算子记录关心的数据，然后在MindInsight服务看板中进行可视化展示，根据MindInsight服务中展示的结果调整相应的参数以提高训练精度。\n",
    "\n",
    "以上便完成了标量、直方图、图像和张量可视化的体验，我们通过本次体验全面了解了MindSpore执行训练的过程和MindInsight在标量、直方图、图像和张量可视化的应用，理解了如何使用`SummaryColletor`记录训练过程中的标量、直方图、图像和张量数据。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}